home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Contributed / SpriteWorld / SpriteWorld Files / Sources / SpriteCompiler.c < prev    next >
Encoding:
Text File  |  2000-10-06  |  6.8 KB  |  280 lines  |  [TEXT/CWIE]
  1. ///--------------------------------------------------------------------------------------
  2. //    SpriteCompiler.c
  3. //
  4. //    Portions are copyright: © 1991-94 Tony Myles, All rights reserved worldwide.
  5. //
  6. //    Description:    implementation of the sprite compiler
  7. ///--------------------------------------------------------------------------------------
  8.  
  9. #ifndef __TYPES__
  10. #include <Types.h>
  11. #endif
  12.  
  13. #ifndef __MEMORY__
  14. #include <Memory.h>
  15. #endif
  16.  
  17. #ifndef __RESOURCES__
  18. #include <Resources.h>
  19. #endif
  20.  
  21. #ifndef __QUICKDRAW__
  22. #include <QuickDraw.h>
  23. #endif
  24.  
  25. #ifndef __SWCOMMON__
  26. #include <SWCommonHeaders.h>
  27. #endif
  28.  
  29. #ifndef __SPRITEFRAME__
  30. #include <SpriteFrame.h>
  31. #endif
  32.  
  33. #ifndef __SPRITEWORLDUTILS__
  34. #include <SpriteWorldUtils.h>
  35. #endif
  36.  
  37. #ifndef __SPRITECOMPILER__
  38. #include <SpriteCompiler.h>
  39. #endif
  40.  
  41. #include "BlitPixieHeader.h"
  42.  
  43. #pragma mark [68k only:]
  44.  
  45. ///--------------------------------------------------------------------------------------
  46. //    SWCompileSprite
  47. ///--------------------------------------------------------------------------------------
  48.  
  49. SW_FUNC OSErr SWCompileSprite(
  50.     SpritePtr srcSpriteP)
  51. {
  52.     OSErr             err = noErr;
  53. #if SW_68K
  54.     short            frame;
  55.  
  56.     for (frame = 0; (err == noErr) && (frame < srcSpriteP->numFrames); frame++)
  57.     {
  58.         err = SWCompileFrame( srcSpriteP->frameArray[frame] );
  59.     }
  60.     
  61.     SWSetStickyIfError( err );
  62. #else
  63.     #pragma unused(srcSpriteP)
  64. #endif
  65.     return err;
  66. }
  67.  
  68.  
  69. ///--------------------------------------------------------------------------------------
  70. //    SWCompileFrame
  71. ///--------------------------------------------------------------------------------------
  72.  
  73. SW_FUNC OSErr SWCompileFrame(
  74.     FramePtr srcFrameP)
  75. {
  76.     OSErr             err = noErr;
  77. #if SW_68K
  78.     PixelCodeHdl     newPixCodeH = NULL;
  79.     Boolean            lockedState;
  80.     RectPtr            frameRectP;
  81.     unsigned long     maskBaseOffset;
  82.  
  83.         // can't do this stuff if the Frame is unlocked
  84.     lockedState = srcFrameP->isFrameLocked;
  85.     if ( lockedState == false )
  86.         SWLockFrame(srcFrameP);
  87.     
  88.     if ( srcFrameP->frameDepth < 8 || 
  89.          (**srcFrameP->framePixHndl).pixelSize != (**srcFrameP->maskPixHndl).pixelSize )
  90.     {
  91.         err = kWrongDepthErr;
  92.     }
  93.  
  94.     if ( srcFrameP->maskPort == NULL )
  95.         err = kWrongMaskErr;
  96.         
  97.     if ( err == noErr )
  98.     {
  99.         frameRectP = &srcFrameP->frameRect;
  100.         
  101.         maskBaseOffset =
  102.                     SW_ROWBYTES( srcFrameP, frameRectP->top ) +
  103.                     SW_PIXELBYTES( srcFrameP, frameRectP->left );
  104.  
  105.         err = BlitPixieCodeParsePixels(
  106.                     // offset to the first pixel of the mask
  107.                 (UInt8 *) (srcFrameP->maskBaseAddr + maskBaseOffset),
  108.                     // rowBytes of data
  109.                 srcFrameP->frameRowBytes,
  110.                     // number of bytes in a row
  111.                 SW_PIXELBYTES( srcFrameP, frameRectP->right - frameRectP->left ),
  112.                     // number of rows
  113.                 (frameRectP->bottom - frameRectP->top),
  114.                     // receives handle to compiled mask
  115.                 &newPixCodeH);
  116.     
  117.         if (err == noErr)
  118.         {
  119.                 // get rid of old compiled mask, if any
  120.             if ( srcFrameP->pixCodeH != NULL )
  121.                 DisposeHandle( (Handle)srcFrameP->pixCodeH );
  122.         
  123.                 // attach the new one
  124.             srcFrameP->pixCodeH = (CompiledHandle) newPixCodeH;
  125.         }
  126.     }
  127.     
  128.     if ( lockedState == false )
  129.         SWUnlockFrame(srcFrameP);
  130.     if ( lockedState == true && err == noErr )
  131.     {
  132.         HLock((Handle)srcFrameP->pixCodeH);
  133.         srcFrameP->frameBlitterP = *srcFrameP->pixCodeH;
  134.     }
  135.             
  136.     SWSetStickyIfError( err );
  137. #else
  138.     #pragma unused(srcFrameP)
  139. #endif
  140.     return err;
  141. }
  142.  
  143. #pragma mark -
  144.  
  145.  
  146. ///--------------------------------------------------------------------------------------
  147. //    SWCreateRLEData
  148. ///--------------------------------------------------------------------------------------
  149.  
  150. SW_FUNC OSErr SWCreateRLEData(
  151.     SpritePtr srcSpriteP)
  152. {
  153.     OSErr                 err = noErr;
  154.     short                frame;
  155.     FramePtr            srcFrameP;
  156.     RLEPixelDataHdl        spriteData,oldData;
  157.     TokenDataHdl        frameData;
  158.     unsigned short        depth;
  159.     short                 maxWidth, maxHeight;
  160.     RectPtr                rectP;
  161.     Boolean                lockedState;
  162.     unsigned long        srcBaseOffset;
  163.     
  164.     depth = srcSpriteP->frameArray[0]->frameDepth;
  165.     if ( depth != 8 && depth != 16 && depth != 32)
  166.         err = kWrongDepthErr;
  167.  
  168.     oldData = (RLEPixelDataHdl) srcSpriteP->frameArray[0]->rleDataH;
  169.             
  170.     maxWidth = 0;
  171.     maxHeight = 0;
  172.  
  173.         // calculate max width/height and check depths
  174.     for (frame = 0; (err == noErr) && (frame < srcSpriteP->numFrames); frame++)
  175.     {
  176.         srcFrameP = srcSpriteP->frameArray[frame];
  177.         
  178.         rectP = &srcFrameP->frameRect;
  179.     
  180.         if ( srcFrameP->frameDepth != depth )
  181.             err = kWrongDepthErr;
  182.             
  183.         if ( rectP->right - rectP->left > maxWidth ) 
  184.         {
  185.             maxWidth = rectP->right - rectP->left;
  186.         }
  187.         if ( rectP->bottom - rectP->top > maxHeight ) 
  188.         {
  189.             maxHeight = rectP->bottom - rectP->top;
  190.         }
  191.     }
  192.  
  193.     spriteData = (RLEPixelDataHdl) NewHandle( kRLEResourceHeaderSize );
  194.     if ( err == noErr && spriteData != NULL )
  195.     {
  196.             // set RLE data header
  197.         (**spriteData).width = maxWidth;
  198.         (**spriteData).height = maxHeight;
  199.         (**spriteData).depth = depth;
  200.         (**spriteData).palette = 0;        // 'clut' res ID, 0 for default
  201.         (**spriteData).frames = srcSpriteP->numFrames;
  202.         (**spriteData).reserved1 = 0;
  203.         (**spriteData).reserved2 = 0;
  204.         (**spriteData).reserved3 = 0;
  205.         
  206.         for (frame = 0; (err == noErr) && (frame < srcSpriteP->numFrames); frame++)
  207.         {
  208.             srcFrameP = srcSpriteP->frameArray[frame];
  209.             rectP = &srcFrameP->frameRect;
  210.         
  211.             if ( srcFrameP->maskPort == NULL )
  212.             {
  213.                 err = kWrongMaskErr;
  214.                 break;
  215.             }
  216.             
  217.                 // can't do this stuff if the Frame is unlocked
  218.             lockedState = srcFrameP->isFrameLocked;
  219.             if ( lockedState == false )
  220.                 SWLockFrame(srcFrameP);
  221.  
  222.             srcBaseOffset =
  223.                     SW_ROWBYTES( srcFrameP, rectP->top ) +
  224.                     SW_PIXELBYTES( srcFrameP, rectP->left );
  225.  
  226.             SW_ASSERT( srcFrameP->frameBaseAddr != NULL );
  227.             SW_ASSERT( srcFrameP->maskBaseAddr != NULL );
  228.  
  229.             err = BlitPixieRLEParsePixels(
  230.                     // offset to the first pixel of the image
  231.                 (UInt8 *) (srcFrameP->frameBaseAddr + srcBaseOffset),
  232.                     // offset to the first pixel of the mask
  233.                 (UInt8 *) (srcFrameP->maskBaseAddr + srcBaseOffset),
  234.                     // rowBytes of data
  235.                 srcFrameP->frameRowBytes,
  236.                     // number of bytes in a row
  237.                 SW_PIXELBYTES( srcFrameP, rectP->right - rectP->left ),
  238.                     // number of rows
  239.                 (rectP->bottom - rectP->top),
  240.                     // bit depth
  241.                 depth,
  242.                     // receives handle to compiled mask
  243.                 &frameData);
  244.     
  245.             if ( err == noErr && frameData != NULL)
  246.             {
  247.                 srcFrameP->rleDataH = (RLETokenHandle) spriteData;
  248.                 srcFrameP->rleTokenStart = (RLETokenPtr) (*spriteData + GetHandleSize((Handle) spriteData));
  249.                 
  250.                     // add this frame's data to the sprite data
  251.                 HLock((Handle) frameData);
  252.                 err = HandAndHand( (Handle) frameData, (Handle) spriteData );
  253.             
  254.                 DisposeHandle( (Handle) frameData );
  255.             }
  256.             
  257.             if ( lockedState == false )
  258.                 SWUnlockFrame(srcFrameP);
  259.         }
  260.     
  261.         if ( err != noErr )
  262.             DisposeHandle( (Handle) spriteData );
  263.         else
  264.         {
  265.                 // if there was old RLE data, dispose of the (shared) handle now
  266.             if ( oldData != NULL )
  267.                 DisposeHandle( (Handle) oldData );
  268.         }
  269.     }
  270.     else
  271.     {
  272.         if ( err == noErr )
  273.             err = MemError();
  274.     }
  275.                          
  276.     SWSetStickyIfError( err );
  277.     return err;
  278. }
  279.  
  280.